// // ✅ 工具函数（放在 Page({}) 外部顶部）
// function formatTime(time) {
//   const date = new Date(time);
//   const y = date.getFullYear();
//   const m = String(date.getMonth() + 1).padStart(2, '0');
//   const d = String(date.getDate()).padStart(2, '0');
//   const h = String(date.getHours()).padStart(2, '0');
//   const min = String(date.getMinutes()).padStart(2, '0');
//   return `${y}-${m}-${d} ${h}:${min}`;
// }

// const db = wx.cloud.database()
// const app = getApp()

// Page({
//   data: {
//     list: [],
//     medicineList: [],
//     aiAnalysis: null,
//     filteredAnalysis: [],
//     showAnalysisPanel: false,
//     isAnalyzing: false,
//     analysisStatus: '',
//     envId: 'wzc-6gdn7zlt14380334',
//     lastUpdateTime: '',
//     activeTab: 'interaction', // 当前选中的标签: interaction, inventory, usage
//     unreadTips: 0,
//   },

//   upload() {
//     wx.navigateTo({ url: '/pages/uploadmedicine/uploadmedicine' })
//   },

//   async get() {
//     const res = await db.collection("medicine").get();
//     const list = res.data || [];

//     list.forEach(item => {
//       if (item.updateTime) {
//         item.updateTime = formatTime(item.updateTime);
//       } else {
//         item.updateTime = '无记录';
//       }
//     });

//     this.setData({
//       list,
//       medicineList: list
//     });

//     const signature = this.getMedicineSignature(list);
//     const cached = await this.getCachedAnalysis(signature);
//     if (cached) {
//       this.setData({
//         aiAnalysis: cached,
//         analysisStatus: '来自缓存',
//         lastUpdateTime: formatTime(new Date())
//       });
//       this.getFilteredAnalysis();
//     } else {
//       this.analyzeWithAI();
//     }
//   },
  

  

//   getMedicineSignature(list) {
//     return [...list]
//       .sort((a, b) => a.name.localeCompare(b.name))
//       .map(item => `${item.name}-${item.num || 0}-${item.dosage || ''}`)
//       .join('|')
//   },

//   async getCachedAnalysis(signature) {
//     const res = await db.collection('medicine_analysis_logs')
//       .where({ signature })
//       .orderBy('createdAt', 'desc')
//       .limit(1).get()

//     return res.data.length > 0 ? res.data[0].analysis : null
//   },

//   async analyzeWithAI() {
//     const list = this.data.medicineList;
//     if (!list.length) return;

//     this.setData({ isAnalyzing: true, analysisStatus: '分析中...' });

//     const medicines = list.map(item => ({
//       name: item.name,
//       num: item.num,
//       dosage: item.dosage,
//       usage: item.usage || '',
//       unit: item.unit || ''
//     }));
//     try {
//       const model = wx.cloud.extend.AI.createModel('deepseek');
//       const medicineListStr = medicines.map(m => `${m.name}(${m.dosage}${m.unit} ${m.usage})`).join(', ');
    
//       const res = await model.generateText({
//         model: 'deepseek-r1',
//         messages: [
//           {
//             role: 'system',
//             content: `你是一个药品分析专家。请根据用户提供的药品列表，分析以下三类内容：
        
//         1. 相互作用：分析药品之间的配伍禁忌或增强毒性。
//         2. 高风险禁忌：指出不适合使用该药的患者类型，如孕妇、儿童、肾病患者。
//         3. 服药注意事项：如服药时间（饭前/后）、整粒吞服、是否需皮试等。不包含剂量。
        
//         输出格式如下，只能返回合法 JSON：
        
//         [
//           {
//             "type": "相互作用",
//             "title": "相互作用分析",
//             "details": [
//               { "key": "药品A + 药品B", "value": "可能增加出血风险" }
//             ]
//           },
//           {
//             "type": "高风险禁忌",
//             "title": "禁忌人群与使用限制",
//             "details": [
//               { "key": "布洛芬", "value": "孕妇慎用，肾功能不全患者禁用" }
//             ]
//           },
//           {
//             "type": "用法建议",
//             "title": "服药注意事项",
//             "details": [
//               { "key": "奥美拉唑", "value": "晨起空腹整粒吞服" }
//             ]
//           }
//         ]
        
//         ⚠️ 不要输出 Markdown（如 \`\`\`json），也不要添加解释说明文字。只输出 JSON 结构。`
//           },
//           {
//             role: 'user',
//             content: `请分析以下药品：${medicineListStr}`
//           }
//         ]
        
//         ,
//         temperature: 0.3,
//         max_tokens: 1000
//       });
    
//       // ✅ 修正部分开始
//       let content = res.choices[0].message.content.trim();
//       if (content.startsWith('```')) {
//         content = content.replace(/^```[a-z]*\\n?/i, '').replace(/```$/, '').trim();
//       }
    
//       let parsed;
//       try {
//         parsed = JSON.parse(content);
//       } catch (err) {
//         console.error('AI 返回内容 JSON 解析失败:', content);
//         this.setData({ isAnalyzing: false, analysisStatus: 'AI返回异常格式' });
//         return;
//       }
//       // ✅ 修正部分结束
    
//       await this.saveAnalysisToDB(this.getMedicineSignature(list), list, parsed);
//       this.setData({
//         aiAnalysis: parsed,
//         isAnalyzing: false,
//         analysisStatus: '分析完成',
//         lastUpdateTime: formatTime(new Date())
//       });
//       this.getFilteredAnalysis();
//     } catch (err) {
//       console.error('AI分析失败:', err);
//       this.setData({ isAnalyzing: false, analysisStatus: '分析失败' });
//     }
//   },

//   async saveAnalysisToDB(signature, medicines, analysis) {
//     await db.collection('medicine_analysis_logs').where({ signature }).remove()
//     await db.collection('medicine_analysis_logs').add({
//       data: {
//         signature,
//         medicines,
//         analysis,
//         createdAt: db.serverDate()
//       }
//     })
//   },

//   getFilteredAnalysis() {
//     const tabTypeMap = {
//       interaction: '相互作用',
//       inventory: '高风险禁忌',
//       usage: '用法建议'
//     };
//     const currentType = tabTypeMap[this.data.activeTab] || '相互作用';

//     const filtered = (this.data.aiAnalysis || []).filter(item => item.type === currentType);
//     this.setData({ filteredAnalysis: filtered });
//   },

//   switchTab(e) {
//     const tab = e.currentTarget.dataset.tab;
//     this.setData({ activeTab: tab }, () => {
//       this.getFilteredAnalysis();
//     });
//   },

//   toggleAnalysisPanel() {
//     this.setData({ showAnalysisPanel: !this.data.showAnalysisPanel });
//   },

//   onLoad() {
//     wx.cloud.init({ env: this.data.envId });
//     this.get();
//     db.collection("medicine").watch({
//       onChange: res => this.get(),
//       onError: err => console.log(err)
//     });
//   },

//   onShow() {
//     this.get();
//   }
// });



// // ✅ 工具函数（放在 Page({}) 外部顶部）
// function formatTime(time) {
//   const date = new Date(time);
//   const y = date.getFullYear();
//   const m = String(date.getMonth() + 1).padStart(2, '0');
//   const d = String(date.getDate()).padStart(2, '0');
//   const h = String(date.getHours()).padStart(2, '0');
//   const min = String(date.getMinutes()).padStart(2, '0');
//   return `${y}-${m}-${d} ${h}:${min}`;
// }
function formatTime(time) {
  // 如果传入的时间格式没有 'T'，手动添加 T，确保 iOS 兼容
  const safeTime = typeof time === 'string' && time.includes(' ') 
    ? time.replace(' ', 'T') 
    : time;

  // 构造一个符合 ISO 8601 格式的时间
  const date = new Date(safeTime);

  // 如果转换失败，返回一个默认值
  if (isNaN(date.getTime())) {
    return '无效时间';
  }

  const y = date.getFullYear();
  const m = String(date.getMonth() + 1).padStart(2, '0');
  const d = String(date.getDate()).padStart(2, '0');
  const h = String(date.getHours()).padStart(2, '0');
  const min = String(date.getMinutes()).padStart(2, '0');

  // 返回格式化的时间，确保没有 'T'
  return `${y}-${m}-${d} ${h}:${min}`;
}



const db = wx.cloud.database()
const app = getApp()

Page({
  data: {
    list: [],
    medicineList: [],
    aiAnalysis: null,
    filteredAnalysis: [],
    showAnalysisPanel: false,
    isAnalyzing: false,
    analysisStatus: '',
    envId: 'wzc-6gdn7zlt14380334',
    lastUpdateTime: '',
    activeTab: 'interaction',
    unreadTips: 0,
    lastMedicineIds: [] // 新增：存储上次的药品ID数组
  },

  upload() {
    wx.navigateTo({ url: '/pages/uploadmedicine/uploadmedicine' })
  },

  async get() {
    const res = await db.collection("medicine").get();
    const list = res.data || [];

    list.forEach(item => {
      if (item.updateTime) {
        item.updateTime = formatTime(item.updateTime);
      } else {
        item.updateTime = '无记录';
      }
    });

    this.setData({
      list,
      medicineList: list
    });

    // 获取当前药品ID数组
    const currentIds = list.map(item => item._id).sort();
    
    // 比较当前ID数组和上次存储的是否相同
    const idsChanged = JSON.stringify(currentIds) !== JSON.stringify(this.data.lastMedicineIds);
    
    if (idsChanged) {
      // ID发生变化，说明有新增或删除药品
      const signature = this.getMedicineSignature(list);
      const cached = await this.getCachedAnalysis(signature);
      if (cached) {
        this.setData({
          aiAnalysis: cached,
          analysisStatus: '来自缓存',
          lastUpdateTime: formatTime(new Date()),
          lastMedicineIds: currentIds // 更新存储的ID数组
        });
        this.getFilteredAnalysis();
      } else {
        this.analyzeWithAI(currentIds);
      }
    } else {
      // ID未变化，仅更新界面不重新分析
      this.setData({
        analysisStatus: '药品未变化，显示上次结果',
        lastUpdateTime: formatTime(new Date())
      });
    }
  },

  getMedicineSignature(list) {
    return [...list]
      .sort((a, b) => a.name.localeCompare(b.name))
      .map(item => `${item.name}-${item.dosage || ''}-${item.usage || ''}`)
      .join('|')
  },

  async getCachedAnalysis(signature) {
    const res = await db.collection('medicine_analysis_logs')
      .where({ signature })
      .orderBy('createdAt', 'desc')
      .limit(1).get()

    return res.data.length > 0 ? res.data[0].analysis : null
  },

  async analyzeWithAI(currentIds) {
    const list = this.data.medicineList;
    if (!list.length) return;

    this.setData({ isAnalyzing: true, analysisStatus: '分析中...' });

    const medicines = list.map(item => ({
      name: item.name,
      num: item.num,
      dosage: item.dosage,
      usage: item.usage || '',
      unit: item.unit || ''
    }));
    try {
      const model = wx.cloud.extend.AI.createModel('deepseek');
      const medicineListStr = medicines.map(m => `${m.name}(${m.dosage}${m.unit} ${m.usage})`).join(', ');
    
      const res = await model.generateText({
        model: 'deepseek-r1',
        messages: [
          {
            role: 'system',
            content: `你是一个药品分析专家。请根据用户提供的药品列表，分析以下三类内容：
        
        1. 相互作用：分析药品之间的配伍禁忌或增强毒性。
        2. 高风险禁忌：指出不适合使用该药的患者类型，如孕妇、儿童、肾病患者。
        3. 服药注意事项：如服药时间（饭前/后）、整粒吞服、是否需皮试等。不包含剂量。
        
        输出格式如下，只能返回合法 JSON：
        
        [
          {
            "type": "相互作用",
            "title": "相互作用分析",
            "details": [
              { "key": "药品A + 药品B", "value": "可能增加出血风险" }
            ]
          },
          {
            "type": "高风险禁忌",
            "title": "禁忌人群与使用限制",
            "details": [
              { "key": "布洛芬", "value": "孕妇慎用，肾功能不全患者禁用" }
            ]
          },
          {
            "type": "用法建议",
            "title": "服药注意事项",
            "details": [
              { "key": "奥美拉唑", "value": "晨起空腹整粒吞服" }
            ]
          }
        ]
        
        ⚠️ 不要输出 Markdown（如 \`\`\`json），也不要添加解释说明文字。只输出 JSON 结构。`
          },
          {
            role: 'user',
            content: `请分析以下药品：${medicineListStr}`
          }
        ],
        temperature: 0.3,
        max_tokens: 1000
      });
    
      let content = res.choices[0].message.content.trim();
      if (content.startsWith('```')) {
        content = content.replace(/^```[a-z]*\\n?/i, '').replace(/```$/, '').trim();
      }
    
      let parsed;
      try {
        parsed = JSON.parse(content);
      } catch (err) {
        console.error('AI 返回内容 JSON 解析失败:', content);
        this.setData({ isAnalyzing: false, analysisStatus: 'AI返回异常格式' });
        return;
      }
    
      const signature = this.getMedicineSignature(list);
      await this.saveAnalysisToDB(signature, list, parsed);
      this.setData({
        aiAnalysis: parsed,
        isAnalyzing: false,
        analysisStatus: '分析完成',
        lastUpdateTime: formatTime(new Date()),
        lastMedicineIds: currentIds // 更新存储的ID数组
      });
      this.getFilteredAnalysis();
    } catch (err) {
      console.error('AI分析失败:', err);
      this.setData({ isAnalyzing: false, analysisStatus: '分析失败' });
    }
  },

  async saveAnalysisToDB(signature, medicines, analysis) {
    await db.collection('medicine_analysis_logs').where({ signature }).remove()
    await db.collection('medicine_analysis_logs').add({
      data: {
        signature,
        medicines,
        analysis,
        createdAt: db.serverDate()
      }
    })
  },

  getFilteredAnalysis() {
    const tabTypeMap = {
      interaction: '相互作用',
      inventory: '高风险禁忌',
      usage: '用法建议'
    };
    const currentType = tabTypeMap[this.data.activeTab] || '相互作用';

    const filtered = (this.data.aiAnalysis || []).filter(item => item.type === currentType);
    this.setData({ filteredAnalysis: filtered });
  },

  switchTab(e) {
    const tab = e.currentTarget.dataset.tab;
    this.setData({ activeTab: tab }, () => {
      this.getFilteredAnalysis();
    });
  },

  toggleAnalysisPanel() {
    this.setData({ showAnalysisPanel: !this.data.showAnalysisPanel });
  },

  onLoad() {
    wx.cloud.init({ env: this.data.envId });
    this.get();
    db.collection("medicine").watch({
      onChange: res => this.get(),
      onError: err => console.log(err)
    });
  },

  onShow() {
    this.get();
  }
});

